processor_base.h File Reference

#include "core/common/wolf.h"
#include "core/common/node_base.h"
#include "core/processor/buffer.h"
#include "core/processor/motion_provider.h"
#include "core/processor/factory_processor.h"
#include "core/frame/frame_base.h"
#include "core/common/time_stamp.h"
#include "core/common/profiling_unit.h"
#include <memory>
#include <map>
#include <chrono>
#include "yaml-cpp/yaml.h"

Go to the source code of this file.

Classes
class	wolf::ProcessorBase

Namespaces
namespace	wolf

Macros
#define	WOLF_PROCESSOR_CREATE(ProcessorClass)
#define	WOLF_PROCESSOR_TEMPLATE_DIM_CREATE(ProcessorClass, Dim)

Macro Definition Documentation

WOLF_PROCESSOR_CREATE

#define WOLF_PROCESSOR_CREATE

(

ProcessorClass

)

Value:

    static ProcessorBasePtr create(const YAML::Node&               _input_node,                                       \
                                   const std::vector<std::string>& _folders_schema = {})                              \
    {                                                                                                                 \
        if (not _folders_schema.empty())                                                                              \
        {                                                                                                             \
            auto server = yaml_schema_cpp::YamlServer(_folders_schema);                                               \
            server.setYaml(_input_node);                                                                              \
            if (not server.applySchema(#ProcessorClass))                                                              \
            {                                                                                                         \
                WOLF_ERROR(server.getLog());                                                                          \
                return nullptr;                                                                                       \
            }                                                                                                         \
            return std::shared_ptr<ProcessorClass>(new ProcessorClass(server.getNode()));                             \
        }                                                                                                             \
        return std::shared_ptr<ProcessorClass>(new ProcessorClass(_input_node));                                      \
    }                                                                                                                 \
    static ProcessorBasePtr create(const std::string&              _yaml_filepath,                                    \
                                   const std::vector<std::string>& _folders_schema)                                   \
    {                                                                                                                 \
        auto server = yaml_schema_cpp::YamlServer(_folders_schema, _yaml_filepath);                                   \
        if (not server.applySchema(#ProcessorClass))                                                                  \
        {                                                                                                             \
            WOLF_ERROR(server.getLog());                                                                              \
            return nullptr;                                                                                           \
        }                                                                                                             \
        return create(server.getNode(), {});                                                                          \
    }

WOLF_PROCESSOR_TEMPLATE_DIM_CREATE

#define WOLF_PROCESSOR_TEMPLATE_DIM_CREATE	(		ProcessorClass,
			Dim
	)

Value:

    static ProcessorBasePtr create(const YAML::Node&               _input_node,                                       \
                                   const std::vector<std::string>& _folders_schema = {})                              \
    {                                                                                                                 \
        if (not _folders_schema.empty())                                                                              \
        {                                                                                                             \
            auto server = yaml_schema_cpp::YamlServer(_folders_schema);                                               \
            server.setYaml(_input_node);                                                                              \
            if (not server.applySchema(#ProcessorClass + std::to_string(Dim) + "d"))                                  \
            {                                                                                                         \
                WOLF_ERROR(server.getLog());                                                                          \
                return nullptr;                                                                                       \
            }                                                                                                         \
            return std::shared_ptr<ProcessorClass<Dim>>(new ProcessorClass<Dim>(server.getNode()));                   \
        }                                                                                                             \
        return std::shared_ptr<ProcessorClass<Dim>>(new ProcessorClass<Dim>(_input_node));                            \
    }                                                                                                                 \
    static ProcessorBasePtr create(const std::string&              _yaml_filepath,                                    \
                                   const std::vector<std::string>& _folders_schema)                                   \
    {                                                                                                                 \
        auto server = yaml_schema_cpp::YamlServer(_folders_schema, _yaml_filepath);                                   \
        if (not server.applySchema(#ProcessorClass + std::to_string(Dim) + "d"))                                      \
        {                                                                                                             \
            WOLF_ERROR(server.getLog());                                                                              \
            return nullptr;                                                                                           \
        }                                                                                                             \
        return create(server.getNode(), {});                                                                          \
    }